home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / kidsf1.1.pl < prev    next >
Perl Script  |  1995-07-27  |  23KB  |  492 lines
  1. #!/usr/skunk/bin/perl
  2. # kidofwais.pl -- WAIS search interface
  3. #   (derived from sonofwais.pl, derived from wais.pl)
  4. #
  5. # a url of "http://your.www.server/cgibindir/kidofwais.pl" will search the
  6. # default WAIS index; a url of the form:
  7. # "http://your.www.server/cgibindir/kidofwais.pl/another_wais_src"
  8. # will search the WAIS index called "another_wais_src".
  9.  
  10. # ----------- wais.pl and derivatives history:
  11. # Tony Sanders <sanders@bsdi.com>, Nov 1993   Original author of wais.pl
  12. #
  13. # by Eric Lease Morgan, NCSU Libraries, April 1994 (sonofwais.pl)
  14. # Modified to present the user "human-readable" titles, better instructions as
  15. # well as the ability to do repeated searches after receiving results.
  16. # eric_morgan@ncsu.edu
  17. # http://dewey.lib.ncsu.edu/staff/morgan/morgan.html
  18. # To read more about this script try:
  19. # http://dewey.lib.ncsu.edu/staff/morgan/son-of-wais.html
  20.  
  21. # NOTE: the "headline" code only works right if you are using the "-t URL"
  22. # option when you create the WAIS index using "waisindex"
  23.  
  24. # ---- Mike Grady, UIUC/CCSO, m-grady@uiuc.edu, http://ewshp2.cso.uiuc.edu/
  25. # further modified by Mike Grady, UIUC/CCSO, June 1994 -- changed title routine
  26. # to use some combination of original here and version from Sean Dowd, EDS
  27. # (that version referred to as wais-ncsa-httpd.pl). Also used file typing idea
  28. # from Sean's version and Kevin Hughes's (EIT) wwwwais.c.
  29.  
  30. # New: Added a hiliting option that works in conjunction with a second cgi
  31. #      script called "print_hit_bold.pl". It attempts to hilite the searchterms
  32. #      which occur in the document, and to place an "anchor" just before the
  33. #      first occurrence so that the document is positioned to there when it
  34. #      is displayed (at least this works with NCSA's HTTPD and Mosaic).
  35. #      Seeing the Encyclopedia Britannica's stuff got me to thinking how I
  36. #      might do this.
  37. #
  38. # also added support for Multitype (multiformat) query responses (using the
  39. # option "-M TYPE1,TYPE2,..." when waisindexing). Waisindex blows up on me
  40. # if I try to use the "-M" option AND the "-t URL" option. And if I tried
  41. # adding a -T option (at least with TEXT), the "headline" ended up being just
  42. # the filename without any path info. So don't use "-t" OR "-T" in conjunction
  43. # with "-M" (the important thing is: make sure the headline field in the
  44. # waisindex src ".cat" file has the form: "filename /path/to/file/" ).
  45. # The alternate forms of the file available are listed following the "Score
  46. # line. Marc Andreeson's "Mosaic And Wais Tutorial" discusses Multiformat
  47. # indexing at "http://wintermute.ncsa.uiuc.edu:8080/wais-tutorial/wais.html".
  48.  
  49. # 6/29/94 -- Now have added in support for optional "title tables", both for
  50. # indices themselves (used as title on "search" page), and for filetypes
  51. # that don't lend themselves to extracting a nice title to display on the
  52. # hit list (in my case, pdf type files).
  53. # 6/30/94 -- Added support for searching multiple indices with one search. This
  54. # uses a "Source table" which serves as both a title table for the indices (as
  55. # mentioned above), and as a "process control table". See the comments in the
  56. # sample table for more description. This is all "turned on" by setting the
  57. # the flag $use_Source_table to "1"; if you set it to "0", no table will be
  58. # expected or used.
  59. # 7/20/94 -- Few minor changes in search "numbers" display: removed "lines"
  60. # since it is often meaningless, changed "bytes" to be rounded to nearest kbyte.
  61. # Small changes to <TITLE> processing in &extractTitle.
  62. # 8/4/94 -- fixed a bug with multi-index code, added DEBUG option
  63. # 8/15/94 -- fixed a bug: occasionally WAIS returns two "odd" files that are
  64. #  information from index.src and index.cat -- exclude these files from list
  65.  
  66. # do we need to debug the returned lines from waisq? If so, write into log.
  67. $DEBUG = 0;     # set to 1 to turn on debugging code; set next to logfile
  68. $debugLOG = "/usr/httpd/logs/kidsf.log";
  69.  
  70. # where is your waiq binary?
  71. $waisq = "/usr/local/bin/waisqsf1.1";
  72.  
  73. # where are your source files?
  74. $waisd = "/usr/wais/wais-sources";
  75.  
  76. # what database do you want to search? (Default)
  77. $default_src = "gruntsco";
  78.  
  79. # what is the opening title you want to present to users (default)
  80. $openingTitle = "Search the gruntsco sf HTML archives";
  81.  
  82. # after searching, what do you want the title to be? (default)
  83. $closingTitle = "Search results from the gruntsco sf HTML archives";
  84.  
  85. # Use a table to look up title (and other info) to use on Search page?
  86. # If 1, then should supply filename for table.
  87. $use_Source_table = 1;
  88. $Source_table = "/usr/wais/wais-sources/Source_table";
  89.  
  90. # Specify the directory where your WWW docs reside -- same as in "kidofwais.pl"
  91. #  (this is the same path you subtracted when you waisindexed (using -t url))
  92. $wwwDocpath = "/b/httpd/doc/";
  93.  
  94. # Specify the url for this WWW server -- same as in "kidofwais.pl" script
  95. #  (this is the same string you added when you waisindexed (using -t url))
  96. $serverURL = "http://gruntsco.pdev.sco.com/";
  97.  
  98. # maximum number of hits to return
  99. $max_hits = 40;
  100.  
  101. # Should we use the "highlighting script" for filetypes that "make sense" for
  102. # it? (1 is yes, 0 is no)
  103. $use_hilite = 0;
  104.  
  105. # specify the www url to the "highlighting script" (used for .html and .txt)
  106. # whether this is used is controlled by $use_hilite flag.
  107. $hilite_script = "http://gruntsco.pdev.sco.com/cgi-bin/print_hit_bold.pl/";
  108.  
  109. # specify the "first hit anchor" to be used with hiliting
  110. $anchor = "#first_hit";
  111.  
  112. # who maintains this service?
  113. #$maintainer = "<A HREF=http://ewshp2.cso.uiuc.edu/index.html>Michael A. Grady</A> (m-grady@uiuc.edu)";
  114. $maintainer = "<A HREF=http://gruntsco.pdev.sco.com/author/hiramc.html>Hiram Clawson (hiramc@sco.COM) x7519</A>";
  115.  
  116. # and when was it last modified.
  117. $modified = "12 May, 1995";
  118.  
  119. # you shouldn't have to edit anything below this line, except if you want to change the help text
  120.  
  121. sub extractTitle {
  122.         # try and get the <title> ... </title> field from file
  123.         # only try to find it in the first 5 lines, and then give up
  124.         local($fl) = @_;
  125.         local($intitle) = 0;
  126.         local($title) = "$theFile: No title, please let $maintainer know.";
  127.         local($linenum) = 1;
  128.         local($_);
  129.  
  130.         # read the file and extract the title
  131.         # this is a combination of code from Eric Lease Morgan and Sean Dowd
  132.         open (FP, "$fl") || return "File $theFile can't be read. Please contact
  133. $maintainer.";
  134.  
  135.         while (<FP>) {
  136.                 chop;
  137.                 last if ($linenum > 5);
  138.                 $linenum ++;
  139.                 if (/<TITLE\s?>(.*)<\/TITLE\s?>/i) { # all on one line
  140.                         $title = $1;
  141.                         last;
  142.                 }
  143.                 elsif (/<TITLE\s?>(.*)$/i) {    # on multiple lines
  144.                         $title = $1;
  145.                         $intitle = 1;
  146.                 }
  147.                 elsif (/^(.*)<\/TITLE\s?>/i) {  # finish of multiple lines
  148.                         $title = "$title$1";
  149.                         $intitle = 0;
  150.                         last;
  151.                 }
  152.                 elsif ($intitle) {              # add to title, and keep going
  153.                         $title = "$title$_";
  154.                 }
  155.         }
  156.         close (FP);
  157.         $title =~ s/^\s*//; # remove whitespace at front
  158.         $title =~ s/\s*$//; # remove whitespace at end
  159.         $title = "$theFile: Empty title, please let $maintainer know." unless $title;
  160.         return $title;
  161. } # end sub extractTitle
  162.  
  163. sub extractTableTitle { # Get file titles from table. Add a call to this
  164.         # routine for any filetype that you decide to create titles for.
  165.         # Currently, only the PDF type is set up to call this. (See the
  166.         # subroutine &type_file). If nothing is found, it returns the current
  167.         # $doc_title unchanged (which is the filename relative to doc root).
  168.         # Table read into array at first reference to it.
  169.         local ($fl) = @_;
  170.         return $doc_title if ($file_title_table eq "");
  171.         local($_,$name_to_find,$table_entry,$filename,$filetitle);
  172.         # Change the next line to "$name_to_find = $theFile" if you want to
  173.         # use the whole path relative to doc root as the name to lookup in the
  174.         # table. The current code uses just the filename w/o path info.
  175.         $name_to_find = substr($fl, rindex($fl, '/') + 1); # "basename"
  176.         if ($current_file_title_array ne $file_title_table) { # Read in new
  177.                                                               # table to array
  178.                 undef %title_array;     # erase current array
  179.                 $current_file_title_array = $file_title_table;
  180.                 open (TABLE_TITLE, $file_title_table) || return $doc_title;
  181.                 while ($table_entry = <TABLE_TITLE>) {
  182.                         chop;
  183.                         next if $table_entry =~ /^\s*#/;  # skip comments
  184.                         next if $table_entry =~ /^\s*$/;  # skip blank lines
  185.                         ($filename, $filetitle) = split(/~/, $table_entry, 2);
  186.                         $title_array{$filename} = $filetitle;
  187.                 }
  188.                 close (TABLE_TITLE);
  189.         }
  190.         if ($filetitle = $title_array{$name_to_find}) { return $filetitle;}
  191.         else { return $doc_title;}
  192. }
  193.  
  194. sub send_index {
  195.     print "Content-type: text/html\n\n";
  196.     
  197.     print "<HEAD>\n<TITLE>$openingTitle</TITLE>\n<ISINDEX></HEAD>\n";
  198.     print "<BODY>\n<H2>", $openingTitle, "</H2>\n";
  199.  
  200.     print "<p>";
  201.     print "This is an index of some of the information on this server. ";
  202.     print "To use this function, simply enter a query. ";
  203.     print "Since this is a WAIS index, you can enter complex queries. For example:<p>";
  204.     print "<DT><B>Right-hand truncation</B> (stemming) queries";
  205.     print "<DD>The query 'astro*' will find documents containing the words";
  206.     print " 'astronomy' as well as 'astrophysics'.<p>";
  207.     print "<DT>Boolean '<B>And</B>' queries";
  208.     print "<DD>The query 'red and blue' will find the <B>intersection</B> of all";
  209.     print " the documents containing the words 'red', and 'blue'.";
  210.     print "The use of 'and' limits your retrieval.<p>";
  211.     print "<DT>Boolean '<B>Or</B>' queries";
  212.     print "<DD>The query 'red or blue' will find the <B>union</B> of all the";
  213.     print " documents containing the words 'red' and 'blue'.";
  214.     print "The use of 'or' increases your retrieval.<p>";
  215.     print "<DT>Boolean '<B>Not</B>' queries";
  216.     print "<DD>The query 'red not green' will find all the documents containing";
  217.     print " the word 'red', and <B>excluding</B> the documents containing the word 'green'.";
  218.     print "The use of 'not' limits your retrieval.<p>";
  219.     print "<DT><B>Nested</B> Boolean queries";
  220.     print "<DD>The query '(red and green) or blue not pink' will find the union of all";
  221.     print " the documents containing the words 'red', and 'green'. It will then add (union)";
  222.     print " all documents containing the word 'blue'. Finally, it will exclude all documents";
  223.     print " containing the word 'pink'";
  224.     print "<HR>";
  225.     print "This page is maintained by $maintainer, and it was last modified on $modified.<p>\n";
  226.     print "</BODY>\n";
  227. }
  228.  
  229. sub type_file {
  230.         # Set file type based on file extension; also has the "side effect" of
  231.         # modifying the $url_to_use if $use_hilite flag is turned on and the
  232.         # file type is appropriate to use it.
  233.         # You can add other types if you want very easily. Also, if you have
  234.         # created a "file_title_table" and want it to be accessed for a 
  235.         # particular filetype, just add "$doc_title = &extractTableTitle ($_);"
  236.         # to the appropriate do{} structure below. See the "pdf" file type
  237.         # below for an example.
  238.         local($filename) = @_;
  239.         local($type) = "";
  240.         local($_);
  241.         SUFFIX: for ($filename) {
  242.                 /\.html$/i      && do {
  243.                                  $type = "HTML file";
  244.                                  $doc_title = &extractTitle ($the_full_File);
  245.                                  if ($use_hilite) {
  246.                                   $url_to_use = $hilite_script . $filename .
  247.                                                 "?" . $query_plus . $anchor;
  248.                                  }
  249.                                  last SUFFIX;
  250.                                 };
  251.                 /\.te?xt$/i     && do {
  252.                                  $type = "text file";
  253.                                  if ($use_hilite) {
  254.                                   $url_to_use = $hilite_script . $filename .
  255.                                                 "?" . $query_plus . $anchor;
  256.                                  }
  257.                                  last SUFFIX;
  258.                                 };
  259.                 /\.gif$/i       && do {
  260.                                  $type = "GIF graphic";
  261.                                  last SUFFIX;
  262.                                 };
  263.                 /\.ps$/i        && do {
  264.                                  $type = "PostScript file";
  265.                                  last SUFFIX;
  266.                                 };
  267.                 /\.pdf$/i       && do {
  268.                                  $type = "Acrobat PDF file";
  269.                                  # try to get a better file title
  270.                                  $doc_title = &extractTableTitle ($_);
  271.                                  last SUFFIX;
  272.                                 };
  273.                 /\.jpg$/i       && do {
  274.                                  $type = "JPEG graphic";
  275.                                  last SUFFIX;
  276.                                 };
  277.                 /\.mpg$/i       && do {
  278.                                  $type = "MPEG movie";
  279.                                  last SUFFIX;
  280.                                 };
  281.                 /\.Z$/i         && do {
  282.                                  $type = "compressed file";
  283.                                  last SUFFIX;
  284.                                 };
  285.                 /\.gz$/i        && do {
  286.                                  $type = "compressed file";
  287.                                  last SUFFIX;
  288.                                 };
  289.                 /\.au$/i        && do {
  290.                                  $type = "Sun audio file";
  291.                                  last SUFFIX;
  292.                                 };
  293.                 /\.hqx$/i       && do {
  294.                                  $type = "Binhex file";
  295.                                  last SUFFIX;
  296.                                 };
  297.                 /\.tar$/i       && do {
  298.                                  $type = "tar'red file";
  299.                                  last SUFFIX;
  300.                                 };
  301.                 $type = "Unknown type"; # "fall thru" default case
  302.         } # end suffix
  303.         return $type;
  304. } # end sub type_file
  305.  
  306. sub byscores { $scores[$b] <=> $scores[$a];} # descending numeric sort routine
  307.  
  308. sub print_it {  # Print out the hit list, or if multiple sources, save all
  309.                 # the info to be printed in a array (where all the info for
  310.                 # "one" hit becomes one array element), only to be printed
  311.                 # once all sources are searched. This is so we can sort the
  312.                 # combined hit lists into descending order by score.
  313.         local($line) = @_;
  314.         if ($src_multiple) {
  315.             if ($line eq "</DL>\n") {   # All sources have been searched, we
  316.                                         # can now sort and print the entire
  317.                                         # hit list array.
  318.                 print @hit_list[ sort byscores $[..$#hit_list ];
  319.                 print "$line";
  320.             } elsif ($line eq "</DD>\n") {      # End of one "hit" listing,
  321.                 $output_hit .= $line;           # save in the hit array.
  322.                 push ( @hit_list, $output_hit );
  323.                 push ( @scores, $score );
  324.                 $output_hit = "";
  325.             } else {    # more stuff for the same hit
  326.                 $output_hit .= $line;
  327.             }
  328.         } else {
  329.                 print "$line";
  330.         }
  331. }
  332.  
  333. sub do_wais {
  334.  
  335.     $src = $default_src;
  336.     # if 'PATH_INFO' has a non-null value, then use it as the name of the
  337.     # WAIS source to search, otherwise will default to $default_src.
  338.     $path_extension = $ENV{'PATH_INFO'};
  339.     if ($path_extension =~ /^\/(.+)$/) { $src = $1; }
  340.     @Sources = ( $src );        # Initialize array of sources to search
  341.     if ( $use_Source_table ) {  # Read in the Source table info into
  342.                                 # associative array.
  343.         open (INDEX_TITLES, $Source_table) || last;
  344.         while (<INDEX_TITLES>) {
  345.                 chop;
  346.                 next if /^\s*#/;        # skip comments
  347.                 next if /^\s*$/;        # skip blank lines
  348.                 ($src_name, $remainder) = split(/~/, $_, 2);
  349.                 $src_array{$src_name} = $remainder;
  350.         }
  351.         close (INDEX_TITLES);
  352.         ($src_title, $src_multiple, $src_prefix, $file_title_table, $sources) =
  353.                                 split(/~/, $src_array{$src});
  354.         if ($src_title ne "") {
  355.                 $openingTitle = "Search of $src_title";
  356.                 $closingTitle = "Search results from $src_title";
  357.         }
  358.         $src_multiple && (@Sources = split(/,/, $sources)); # Store the sources
  359.     }                                                       # to be searched.
  360.  
  361.     do { &send_index; return; } unless defined @ARGV; # No search terms yet.
  362.  
  363.     local(@query) = @ARGV;
  364.     local($pquery) = join(" ", @query);
  365.     # NCSA's HTTPD puts backslashes in front of "funny" or "dangerous"
  366.     # characters in the input supplied thru argv. In the case of search terms
  367.     # for WAIS, this can screw up the search (parens and "*" get backslashed
  368.     # and then don't work correctly). So remove the backslashes, AND the
  369.     # potentially "dangerous" characters ( ; ` ! ).
  370.     $pquery =~ tr/!\;\`\\//d;           # just in case, get rid of ;`! and \
  371.     @query = split(' ',$pquery);        # and recreate query word array
  372.     $query_plus = join("+", @query);
  373.  
  374.     print "Content-type: text/html\n\n"; # Start the "html" doc to be returned
  375.  
  376.     print "<HEAD>\n<TITLE>$closingTitle</TITLE>\n<ISINDEX></HEAD>\n";
  377.     print "<BODY>\n<H2>", $closingTitle, "</H2>\n";
  378.     print "Index <B>\`$src\'</B> contains the following\n";
  379.     print "items relevant to <B>\`$pquery\'</B>:<p>\n";
  380.     print "<DL>\n";
  381.  
  382.     local($hits, $score, $headline, $lines, $bytes, $type, @types, $date);
  383.     $DEBUG && do { open (LOG, ">>$debugLOG") || die "can't open log";};
  384.  
  385.     foreach $src (@Sources) {   # Search each indicated index for the terms
  386.       ($src_prefix, $file_title_table) = (split(/~/, $src_array{$src}))[2,3];
  387.       open(WAISQ, "-|") || exec ($waisq, "-c", $waisd, "-m", $max_hits,
  388.                                 "-f", "-", "-S", "$src.src", "-g", @query);
  389.       while (<WAISQ>) {
  390.         $DEBUG && print LOG $_;
  391.         /:score\s+(\d+)/ && ($score = $1);
  392.         /:number-of-lines\s+(\d+)/ && ($lines = $1);
  393.         /:number-of-bytes\s+(\d+)/ && ($bytes = $1);
  394.         /:type "(.*)"/ && (push (@types, $1));
  395.         /:headline "(.*)"/ && ($headline = $1);
  396.         /:date "(\d+)"/ && ($date = $1, $hits++, &docdone);
  397.       }
  398.       close(WAISQ);
  399.       $total_hits += $hits;
  400.       $hits = 0;
  401.     }
  402.     &print_it ("</DL>\n");      # signal to print out hit array if we've been
  403.                                 # building it (for multiple sources).
  404.     print "<HR>";
  405.     print "This page is maintained by $maintainer.<p>";
  406.     if ($total_hits == 0) { print "Nothing found that matches your query.\n"; }
  407.     print "</BODY>\n";  # End the "html" doc being returned
  408. }
  409.  
  410. sub docdone {   # Called for each "hit" returned by waisq
  411.     local($endfile,$path_to_file,$file_proper,$file_ext,$multi_type,$alt_count);
  412.     if ($headline =~ /Search produced no result/) {
  413.         if ($src_multiple) {  # don't print source listing if
  414.            $hits--;           # multi-index search
  415.         }
  416.         else {
  417.            print "</DL><HR>";
  418.            print $headline, "<p>\n<PRE>";
  419.            local ($count) = 0;
  420.            open(WAISCAT, "$waisd/$src.cat") || die "$src.cat: $!";
  421.            while (<WAISCAT>) {
  422.                last if ($count > 30);  # limit to about 30 filenames
  423.                $count ++;
  424.                s#(Catalog for database:)\s+.*#$1 <B>$src.src</B> -- some of the files are:#;
  425.                s#Headline:\s+(.*)#Headline: <A HREF="$1">$1</A>#;
  426.                print;
  427.            }
  428.            close(WAISCAT);
  429.            print "\n</PRE>\n";
  430.         }
  431.     } elsif (($headline =~ /^Information on database:/) ||
  432.                         ($headline =~ /^Catalog for database:/)) {
  433.         $hits--;
  434.     } else {    # this is a "real" hit
  435.         ($endfile, $path_to_file) = split(' ', $headline);
  436.         if ($path_to_file ne "") { # Not indexed with -t url, so headline of
  437.                                    # form:  "filename /path/to/file/"
  438.                 # Multitype indexed files will probably have this form, as at
  439.                 # least I can't get "-t url" to coexist with "-M type,type"
  440.                 $the_full_File = $theFile = $path_to_file.$endfile;
  441.                 $theFile =~ s/^.*$wwwDocpath//i;
  442.                 $url_to_use = $serverURL.$theFile;
  443.         } else { # should have been indexed as "-t url", so headline of form
  444.                  # http://your_server_url/path/to/actual/file
  445.         
  446.                 # get the string to munge
  447.                 $theFile = $url_to_use = $headline;
  448.  
  449.                 # parse out the file name (remove the server URL from the front)
  450.                 $theFile =~ s/^.*$serverURL//i;
  451.         
  452.                 # concatenate the "wwwDocpath" variable with the file name
  453.                 $the_full_File = $wwwDocpath.$theFile;
  454.         }
  455.  
  456.         $last_period = rindex($theFile, ".");   # need filename without .ext if
  457.         if ($last_period > 0) {                 # it turns out to be multitype
  458.                 $file_proper = substr($theFile, 0, $last_period);
  459.                 $file_ext = substr($theFile, $last_period + 1);
  460.         }
  461.         $doc_title = $theFile;
  462.         $type  = &type_file ($theFile); # also modifies $url_to_use if flag
  463.                                         # $use_hilite is set and right filetype
  464.         $src_multiple && ($doc_title = "$src_prefix $doc_title");
  465.         if ($bytes < 1000) { $calc_bytes = "< 1 Kbyte"; }
  466.         else { $calc_bytes = int(($bytes + 500)/1000) . " Kbytes"; }
  467.         &print_it ("<DT><A HREF=\"$url_to_use\">$doc_title</A></DT>\n");
  468.         &print_it ("<DD>Relevancy score: $score , Size: <B>$calc_bytes</B> , Type: $type\n");
  469.  
  470.         if (($#types > 0) && ($file_proper ne "")) {  # Multitype indexing
  471.           $alt_count = 0;                             # offer alternatives
  472.           foreach $multi_type (@types) {
  473.                 next if $multi_type eq $file_ext; # skip, already listed
  474.                 &print_it ("</DD><DD>... Alternate Types Available: ") if $alt_count == 0;
  475.                 $alt_count ++;
  476.                 $theFile = "$file_proper.$multi_type";
  477.                 $url_to_use = $serverURL.$theFile;
  478.                 $type  = &type_file ($theFile);
  479.                 &print_it ("<A HREF=\"$url_to_use\">$type</A>, ");
  480.           } # end foreach $multi_type
  481.         }
  482.         &print_it ("</DD>\n");
  483.     }
  484.     $score = $headline = $lines = $bytes = $type = $date = '';
  485.     $file_proper = $file_ext = '';
  486.     @types = ();
  487. }
  488.  
  489. open (STDERR,"> /dev/null");
  490. eval '&do_wais';
  491.  
  492.